home *** CD-ROM | disk | FTP | other *** search
/ Aminet 52 / Aminet 52 (2002)(GTI - Schatztruhe)[!][Dec 2002].iso / Aminet / util / moni / Scout-src.lha / source / objects / scout_main.c < prev    next >
Encoding:
C/C++ Source or Header  |  2002-09-17  |  20.9 KB  |  505 lines

  1. /**
  2.  * Scout - The Amiga System Monitor
  3.  *
  4.  *------------------------------------------------------------------
  5.  *
  6.  * This program is free software; you can redistribute it and/or modify
  7.  * it under the terms of the GNU General Public License as published by
  8.  * the Free Software Foundation; either version 2 of the License, or
  9.  * any later version.
  10.  *
  11.  * This program is distributed in the hope that it will be useful,
  12.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.  * GNU General Public License for more details.
  15.  *
  16.  * You should have received a copy of the GNU General Public License
  17.  * along with this program; if not, write to the Free Software
  18.  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19.  *
  20.  * You must not use this source code to gain profit of any kind!
  21.  *
  22.  *------------------------------------------------------------------
  23.  *
  24.  * @author Andreas Gelhausen
  25.  * @author Richard Körber <rkoerber@gmx.de>
  26.  */
  27.  
  28. #include "system_headers.h"
  29.  
  30. #define ScoutWindow(idx, class, cmd) {                                  \
  31.     struct MainWinData *mwd = INST_DATA(cl, obj);                       \
  32.                                                                         \
  33.     if (mwd->mwd_Windows[idx]) {                                        \
  34.         DoMethod(mwd->mwd_Windows[idx], MUIM_Window_ToFront);           \
  35.         set(mwd->mwd_Windows[idx], MUIA_Window_Activate, TRUE);         \
  36.     } else {                                                            \
  37.        APTR win;                                                        \
  38.                                                                         \
  39.        if (win = class, MUIA_Window_ParentWindow, obj,                  \
  40.                         MUIA_Window_MaxChildWindowCount, (opts.SingleWindows) ? 1 : 0, \
  41.                         End) {                                          \
  42.            mwd->mwd_Windows[idx] = win;                                 \
  43.            DoMethod(win, MUIM_Notify, MUIA_Window_CloseRequest,         \
  44.                     TRUE, obj, 3, MUIM_CallHook, &close_callhook, idx); \
  45.            set(win, MUIA_Window_Open, TRUE);                            \
  46.            if (cmd) DoMethod(win, cmd);                                 \
  47.        }                                                                \
  48.     }                                                                   \
  49.                                                                         \
  50.     return 0;                                                           \
  51. }
  52.  
  53. static __asm __saveds LONG close_callfunc( register __a0 struct Hook *hook, register __a1 ULONG *index, register __a2 struct Object *obj )
  54. {
  55.     struct MainWinData *mwd = INST_DATA(OCLASS(obj), obj);
  56.  
  57.     mwd->mwd_Windows[*index] = NULL;
  58.  
  59.     return 0;
  60. }
  61.  
  62. MakeHook(close_callhook, close_callfunc);
  63.  
  64. static ULONG __saveds mNew( struct IClass *cl,
  65.                             Object *obj,
  66.                             struct opSet *msg )
  67. {
  68.     APTR button[30];
  69.  
  70.     if (obj = (Object *)DoSuperNew(cl, obj,
  71.         MUIA_HelpNode, "Main",
  72.         MUIA_Window_ID, MakeID('M','A','I','N'),
  73.         WindowContents, HGroup,
  74.  
  75.             MUIA_Group_SameHeight, TRUE,
  76.             Child, VGroup,                  /* This is the SCOUT logo */
  77.                 MUIA_Weight    , 0,
  78.                 MUIA_Frame     , MUIV_Frame_Text,
  79.                 MUIA_Background, MUII_SHADOW,
  80.                 Child, VSpace(0),
  81.                 Child, BodychunkObject,
  82.                     MUIA_FixWidth, SCOUT_LOGO_WIDTH,
  83.                     MUIA_FixHeight, SCOUT_LOGO_HEIGHT,
  84.                     MUIA_Bitmap_Width, SCOUT_LOGO_WIDTH,
  85.                     MUIA_Bitmap_Height, SCOUT_LOGO_HEIGHT,
  86.                     MUIA_Bodychunk_Depth, SCOUT_LOGO_DEPTH ,
  87.                     MUIA_Bodychunk_Body, scout_logo_body,
  88.                     MUIA_Bodychunk_Compression, SCOUT_LOGO_COMPRESSION,
  89.                     MUIA_Bodychunk_Masking, SCOUT_LOGO_MASKING,
  90.                     MUIA_Bitmap_SourceColors, scout_logo_colors,
  91.                     MUIA_Bitmap_Transparent, FALSE,
  92.                 End,
  93.                 Child, VSpace(0),
  94.             End,
  95.             Child, ColGroup(5), MUIA_Group_SameSize, TRUE,
  96.                 Child, button[ 0] = MakeButton("_Allocations"),
  97.                 Child, button[ 1] = MakeButton("Assi_gns"),
  98.                 Child, button[ 2] = MakeButton("_BoopsiClasses"),
  99.                 Child, button[ 3] = MakeButton("Commodities"),
  100.                 Child, button[ 4] = MakeButton("_Devices"),
  101.  
  102.                 Child, button[ 5] = MakeButton("E_xpansions"),
  103.                 Child, button[ 6] = MakeButton("_Fonts"),
  104.                 Child, button[ 7] = MakeButton("Input_Handlers"),
  105.                 Child, button[ 8] = MakeButton("_Interrupts"),
  106.                 Child, button[ 9] = MakeButton("_Libraries"),
  107.  
  108.                 Child, button[10] = MakeButton("L_ocks"),
  109.                 Child, button[11] = MakeButton("LowMemory"),
  110.                 Child, button[12] = MakeButton("_Memory"),
  111.                 Child, button[13] = MakeButton("Mou_nted Devs"),
  112.                 Child, button[14] = MakeButton("_Ports"),
  113.  
  114.                 Child, button[15] = MakeButton("_Residents"),
  115.                 Child, button[16] = MakeButton("_Commands"),
  116.                 Child, button[17] = MakeButton("Reso_urces"),
  117.                 Child, button[18] = MakeButton("ScreenModes"),
  118.                 Child, button[19] = MakeButton("_Semaphores"),
  119.  
  120.                 Child, button[20] = MakeButton("S_ystem"),
  121.                 Child, button[21] = MakeButton("_Tasks"),
  122.                 Child, button[22] = MakeButton("Tim_er"),
  123.                 Child, button[23] = MakeButton("_Vectors"),
  124.                 Child, button[24] = MakeButton("_Windows"),
  125.  
  126.                 Child, button[25] = MakeButton("Patches"),
  127.                 Child, button[26] = MakeButton("Catalogs"),
  128.                 Child, button[27] = MakeButton("AudioModes"),
  129.                 Child, button[28] = MakeButton("ResetHandlers"),
  130.  
  131.                 Child, HVSpace,
  132.             End,
  133.         End,
  134.         TAG_MORE, msg->ops_AttrList))
  135.     {
  136.         struct MainWinData *mwd = INST_DATA(cl, obj);
  137.         struct PatchPort *pp;
  138.         struct SetManPort *sp;
  139.         struct Library *pc;
  140.  
  141.         set(obj, MUIA_Window_Title, MyGetWindowTitle("\0", mwd->mwd_Title, sizeof(mwd->mwd_Title)));
  142.  
  143.         DoMethod(obj,        MUIM_Notify,  MUIA_Window_CloseRequest, TRUE,  MUIV_Notify_Application, 2, MUIM_Application_ReturnID, MUIV_Application_ReturnID_Quit);
  144.  
  145.         DoMethod(button[ 0], MUIM_Notify,  MUIA_Pressed, FALSE, obj, 1, MUIM_MainWin_ShowAllocations);
  146.         DoMethod(button[ 1], MUIM_Notify,  MUIA_Pressed, FALSE, obj, 1, MUIM_MainWin_ShowAssigns);
  147.         DoMethod(button[ 2], MUIM_Notify,  MUIA_Pressed, FALSE, obj, 1, MUIM_MainWin_ShowClasses);
  148.         DoMethod(button[ 3], MUIM_Notify,  MUIA_Pressed, FALSE, obj, 1, MUIM_MainWin_ShowCommodities);
  149.         DoMethod(button[ 4], MUIM_Notify,  MUIA_Pressed, FALSE, obj, 1, MUIM_MainWin_ShowDevices);
  150.         DoMethod(button[ 5], MUIM_Notify,  MUIA_Pressed, FALSE, obj, 1, MUIM_MainWin_ShowExpansions);
  151.         DoMethod(button[ 6], MUIM_Notify,  MUIA_Pressed, FALSE, obj, 1, MUIM_MainWin_ShowFonts);
  152.         DoMethod(button[ 7], MUIM_Notify,  MUIA_Pressed, FALSE, obj, 1, MUIM_MainWin_ShowInputHandlers);
  153.         DoMethod(button[ 8], MUIM_Notify,  MUIA_Pressed, FALSE, obj, 1, MUIM_MainWin_ShowInterrupts);
  154.         DoMethod(button[ 9], MUIM_Notify,  MUIA_Pressed, FALSE, obj, 1, MUIM_MainWin_ShowLibraries);
  155.         DoMethod(button[10], MUIM_Notify,  MUIA_Pressed, FALSE, obj, 1, MUIM_MainWin_ShowLocks);
  156.         DoMethod(button[11], MUIM_Notify,  MUIA_Pressed, FALSE, obj, 1, MUIM_MainWin_ShowLowMemory);
  157.         DoMethod(button[12], MUIM_Notify,  MUIA_Pressed, FALSE, obj, 1, MUIM_MainWin_ShowMemory);
  158.         DoMethod(button[13], MUIM_Notify,  MUIA_Pressed, FALSE, obj, 1, MUIM_MainWin_ShowMounts);
  159.         DoMethod(button[14], MUIM_Notify,  MUIA_Pressed, FALSE, obj, 1, MUIM_MainWin_ShowPorts);
  160.         DoMethod(button[15], MUIM_Notify,  MUIA_Pressed, FALSE, obj, 1, MUIM_MainWin_ShowResidents);
  161.         DoMethod(button[16], MUIM_Notify,  MUIA_Pressed, FALSE, obj, 1, MUIM_MainWin_ShowCommands);
  162.         DoMethod(button[17], MUIM_Notify,  MUIA_Pressed, FALSE, obj, 1, MUIM_MainWin_ShowResources);
  163.         DoMethod(button[18], MUIM_Notify,  MUIA_Pressed, FALSE, obj, 1, MUIM_MainWin_ShowScreenModes);
  164.         DoMethod(button[19], MUIM_Notify,  MUIA_Pressed, FALSE, obj, 1, MUIM_MainWin_ShowSemaphores);
  165.         DoMethod(button[20], MUIM_Notify,  MUIA_Pressed, FALSE, obj, 1, MUIM_MainWin_ShowSystem);
  166.         DoMethod(button[21], MUIM_Notify,  MUIA_Pressed, FALSE, obj, 1, MUIM_MainWin_ShowTasks);
  167.         DoMethod(button[22], MUIM_Notify,  MUIA_Pressed, FALSE, obj, 1, MUIM_MainWin_ShowTimers);
  168.         DoMethod(button[23], MUIM_Notify,  MUIA_Pressed, FALSE, obj, 1, MUIM_MainWin_ShowVectors);
  169.         DoMethod(button[24], MUIM_Notify,  MUIA_Pressed, FALSE, obj, 1, MUIM_MainWin_ShowWindows);
  170.         DoMethod(button[25], MUIM_Notify,  MUIA_Pressed, FALSE, obj, 1, MUIM_MainWin_ShowPatches);
  171.         DoMethod(button[26], MUIM_Notify,  MUIA_Pressed, FALSE, obj, 1, MUIM_MainWin_ShowCatalogs);
  172.         DoMethod(button[27], MUIM_Notify,  MUIA_Pressed, FALSE, obj, 1, MUIM_MainWin_ShowAudioModes);
  173.         DoMethod(button[28], MUIM_Notify,  MUIA_Pressed, FALSE, obj, 1, MUIM_MainWin_ShowResetHandlers);
  174.  
  175.         Forbid();
  176.         pp = (struct PatchPort *)FindPort(PATCHPORT_NAME);
  177.         sp = (struct SetManPort *)FindPort(SETMANPORT_NAME);
  178.         pc = (struct Library *)OpenResource(PATCHRES_NAME);
  179.         Permit();
  180.         set(button[25], MUIA_Disabled, (pp == NULL && sp == NULL && pc == NULL));
  181.     }
  182.  
  183.     return (ULONG)obj;
  184. }
  185.  
  186. static ULONG __saveds mDispose( struct IClass *cl,
  187.                                 Object *obj,
  188.                                 struct opSet *msg )
  189. {
  190.     set(obj, MUIA_Window_Open, FALSE);
  191.  
  192.     return (DoSuperMethodA(cl, obj, msg));
  193. }
  194.  
  195. static ULONG __saveds mAbout( struct IClass *cl,
  196.                               Object *obj,
  197.                               Msg msg )
  198. {
  199.     APTR aboutWin;
  200.  
  201.     if (aboutWin = AboutWindowObject,
  202.             MUIA_Window_ParentWindow, obj,
  203.             MUIA_Window_NoMenus, TRUE,
  204.         End) {
  205.         APTR app;
  206.  
  207.         get(obj, MUIA_ApplicationObject, &app);
  208.         DoMethod(app, OM_ADDMEMBER, aboutWin);
  209.  
  210.         DoMethod(aboutWin, MUIM_AboutWin_About);
  211.  
  212.         DoMethod(app, OM_REMMEMBER, aboutWin);
  213.  
  214.         MUI_DisposeObject(aboutWin);
  215.     }
  216.  
  217.     return 0;
  218. }
  219.  
  220. static ULONG __saveds mShowAllocations( struct IClass *cl,
  221.                                         Object *obj,
  222.                                         Msg msg )
  223. {
  224.     ScoutWindow(0, AllocationsWindowObject, MUIM_AllocationsWin_Update);
  225. }
  226.  
  227. static ULONG __saveds mShowAssigns( struct IClass *cl,
  228.                                     Object *obj,
  229.                                     Msg msg )
  230. {
  231.     ScoutWindow(1, AssignsWindowObject, MUIM_AssignsWin_Update);
  232. }
  233.  
  234. static ULONG __saveds mShowClasses( struct IClass *cl,
  235.                                     Object *obj,
  236.                                     Msg msg )
  237. {
  238.     ScoutWindow(2, ClassesWindowObject, MUIM_ClassesWin_Update);
  239. }
  240.  
  241. static ULONG __saveds mShowCommodities( struct IClass *cl,
  242.                                         Object *obj,
  243.                                         Msg msg )
  244. {
  245.     ScoutWindow(3, CommoditiesWindowObject, MUIM_CommoditiesWin_Update);
  246. }
  247.  
  248. static ULONG __saveds mShowDevices( struct IClass *cl,
  249.                                     Object *obj,
  250.                                     Msg msg )
  251. {
  252.     ScoutWindow(4, DevicesWindowObject, MUIM_DevicesWin_Update);
  253. }
  254.  
  255. static ULONG __saveds mShowExpansions( struct IClass *cl,
  256.                                        Object *obj,
  257.                                        Msg msg )
  258. {
  259.     ScoutWindow(5, ExpansionsWindowObject, MUIM_ExpansionsWin_Update);
  260. }
  261.  
  262. static ULONG __saveds mShowFonts( struct IClass *cl,
  263.                                   Object *obj,
  264.                                   Msg msg )
  265. {
  266.     ScoutWindow(6, FontsWindowObject, MUIM_FontsWin_Update);
  267. }
  268.  
  269. static ULONG __saveds mShowInputHandlers( struct IClass *cl,
  270.                                           Object *obj,
  271.                                           Msg msg )
  272. {
  273.     ScoutWindow(7, InputHandlersWindowObject, MUIM_InputHandlersWin_Update);
  274. }
  275.  
  276. static ULONG __saveds mShowInterrupts( struct IClass *cl,
  277.                                        Object *obj,
  278.                                        Msg msg )
  279. {
  280.     ScoutWindow(8, InterruptsWindowObject, MUIM_InterruptsWin_Update);
  281. }
  282.  
  283. static ULONG __saveds mShowLibraries( struct IClass *cl,
  284.                                       Object *obj,
  285.                                       Msg msg )
  286. {
  287.     ScoutWindow(9, LibrariesWindowObject, MUIM_LibrariesWin_Update);
  288. }
  289.  
  290. static ULONG __saveds mShowLocks( struct IClass *cl,
  291.                                   Object *obj,
  292.                                   Msg msg )
  293. {
  294.     ScoutWindow(10, LocksWindowObject, 0);
  295. }
  296.  
  297. static ULONG __saveds mShowLowMemory( struct IClass *cl,
  298.                                       Object *obj,
  299.                                       Msg msg )
  300. {
  301.     ScoutWindow(11, LowMemoryWindowObject, MUIM_LowMemoryWin_Update);
  302. }
  303.  
  304. static ULONG __saveds mShowMemory( struct IClass *cl,
  305.                                    Object *obj,
  306.                                    Msg msg )
  307. {
  308.     ScoutWindow(12, MemoryWindowObject, MUIM_MemoryWin_Update);
  309. }
  310.  
  311. static ULONG __saveds mShowMounts( struct IClass *cl,
  312.                                    Object *obj,
  313.                                    Msg msg )
  314. {
  315.     ScoutWindow(13, MountsWindowObject, MUIM_MountsWin_Update);
  316. }
  317.  
  318. static ULONG __saveds mShowPorts( struct IClass *cl,
  319.                                   Object *obj,
  320.                                   Msg msg )
  321. {
  322.     ScoutWindow(14, PortsWindowObject, MUIM_PortsWin_Update);
  323. }
  324.  
  325. static ULONG __saveds mShowResidents( struct IClass *cl,
  326.                                       Object *obj,
  327.                                       Msg msg )
  328. {
  329.     ScoutWindow(15, ResidentsWindowObject, MUIM_ResidentsWin_Update);
  330. }
  331.  
  332. static ULONG __saveds mShowCommands( struct IClass *cl,
  333.                                      Object *obj,
  334.                                      Msg msg )
  335. {
  336.     ScoutWindow(16, CommandsWindowObject, MUIM_CommandsWin_Update);
  337. }
  338.  
  339. static ULONG __saveds mShowResources( struct IClass *cl,
  340.                                       Object *obj,
  341.                                       Msg msg )
  342. {
  343.     ScoutWindow(17, ResourcesWindowObject, MUIM_ResourcesWin_Update);
  344. }
  345.  
  346. static ULONG __saveds mShowScreenModes( struct IClass *cl,
  347.                                         Object *obj,
  348.                                         Msg msg )
  349. {
  350.     ScoutWindow(18, ScreenModesWindowObject, MUIM_ScreenModesWin_Update);
  351. }
  352.  
  353. static ULONG __saveds mShowSemaphores( struct IClass *cl,
  354.                                        Object *obj,
  355.                                        Msg msg )
  356. {
  357.     ScoutWindow(19, SemaphoresWindowObject, MUIM_SemaphoresWin_Update);
  358. }
  359.  
  360. static ULONG __saveds mShowSystem( struct IClass *cl,
  361.                                    Object *obj,
  362.                                    Msg msg )
  363. {
  364.     ScoutWindow(20, SystemWindowObject, MUIM_SystemWin_Update);
  365. }
  366.  
  367. static ULONG __saveds mShowTasks( struct IClass *cl,
  368.                                   Object *obj,
  369.                                   Msg msg )
  370. {
  371.     ScoutWindow(21, TasksWindowObject, MUIM_TasksWin_Update);
  372. }
  373.  
  374. static ULONG __saveds mShowTimers( struct IClass *cl,
  375.                                    Object *obj,
  376.                                    Msg msg )
  377. {
  378.     ScoutWindow(22, TimersWindowObject, MUIM_TimersWin_Update);
  379. }
  380.  
  381. static ULONG __saveds mShowVectors( struct IClass *cl,
  382.                                     Object *obj,
  383.                                     Msg msg )
  384. {
  385.     ScoutWindow(23, VectorsWindowObject, MUIM_VectorsWin_Update);
  386. }
  387.  
  388. static ULONG __saveds mShowWindows( struct IClass *cl,
  389.                                     Object *obj,
  390.                                     Msg msg )
  391. {
  392.     ScoutWindow(24, WindowsWindowObject, MUIM_WindowsWin_Update);
  393. }
  394.  
  395. static ULONG __saveds mShowPatches( struct IClass *cl,
  396.                                     Object *obj,
  397.                                     Msg msg )
  398. {
  399.     ScoutWindow(25, PatchesWindowObject, MUIM_PatchesWin_Update);
  400. }
  401.  
  402. static ULONG __saveds mShowCatalogs( struct IClass *cl,
  403.                                     Object *obj,
  404.                                     Msg msg )
  405. {
  406.     ScoutWindow(26, CatalogsWindowObject, MUIM_CatalogsWin_Update);
  407. }
  408.  
  409. static ULONG __saveds mShowAudioModes( struct IClass *cl,
  410.                                        Object *obj,
  411.                                        Msg msg )
  412. {
  413.     ScoutWindow(27, AudioModesWindowObject, MUIM_AudioModesWin_Update);
  414. }
  415.  
  416. static ULONG __saveds mShowResetHandlers( struct IClass *cl,
  417.                                           Object *obj,
  418.                                           Msg msg )
  419. {
  420.     ScoutWindow(28, ResetHandlersWindowObject, MUIM_ResetHandlersWin_Update);
  421. }
  422.  
  423. static ULONG __saveds mFlushDevices( struct IClass *cl,
  424.                                      Object *obj,
  425.                                      Msg msg )
  426. {
  427.     MyDoCommand("FLUSHDEVS");
  428.  
  429.     return 0;
  430. }
  431.  
  432. static ULONG __saveds mFlushFonts( struct IClass *cl,
  433.                                    Object *obj,
  434.                                    Msg msg )
  435. {
  436.     MyDoCommand("FLUSHFONTS");
  437.  
  438.     return 0;
  439. }
  440.  
  441. static ULONG __saveds mFlushLibraries( struct IClass *cl,
  442.                                        Object *obj,
  443.                                        Msg msg )
  444. {
  445.     MyDoCommand("FLUSHLIBS");
  446.  
  447.     return 0;
  448. }
  449.  
  450. static ULONG __saveds mFlushAll( struct IClass *cl,
  451.                                  Object *obj,
  452.                                  Msg msg )
  453. {
  454.     MyDoCommand("FLUSHALL");
  455.  
  456.     return 0;
  457. }
  458.  
  459. ULONG __asm __saveds MainWinDispatcher( register __a0 struct IClass *cl,
  460.                                         register __a2 Object *obj,
  461.                                         register __a1 Msg msg )
  462. {
  463.     switch (msg->MethodID) {
  464.         case OM_NEW:                         return (mNew(cl, obj, (APTR)msg));
  465.         case OM_DISPOSE:                     return (mDispose(cl, obj, (APTR)msg));
  466.         case MUIM_MainWin_About:             return (mAbout(cl, obj, (APTR)msg));
  467.         case MUIM_MainWin_ShowAllocations:   return (mShowAllocations(cl, obj, (APTR)msg));
  468.         case MUIM_MainWin_ShowAssigns:       return (mShowAssigns(cl, obj, (APTR)msg));
  469.         case MUIM_MainWin_ShowClasses:       return (mShowClasses(cl, obj, (APTR)msg));
  470.         case MUIM_MainWin_ShowCommodities:   return (mShowCommodities(cl, obj, (APTR)msg));
  471.         case MUIM_MainWin_ShowDevices:       return (mShowDevices(cl, obj, (APTR)msg));
  472.         case MUIM_MainWin_ShowExpansions:    return (mShowExpansions(cl, obj, (APTR)msg));
  473.         case MUIM_MainWin_ShowFonts:         return (mShowFonts(cl, obj, (APTR)msg));
  474.         case MUIM_MainWin_ShowInputHandlers: return (mShowInputHandlers(cl, obj, (APTR)msg));
  475.         case MUIM_MainWin_ShowInterrupts:    return (mShowInterrupts(cl, obj, (APTR)msg));
  476.         case MUIM_MainWin_ShowLibraries:     return (mShowLibraries(cl, obj, (APTR)msg));
  477.         case MUIM_MainWin_ShowLocks:         return (mShowLocks(cl, obj, (APTR)msg));
  478.         case MUIM_MainWin_ShowLowMemory:     return (mShowLowMemory(cl, obj, (APTR)msg));
  479.         case MUIM_MainWin_ShowMemory:        return (mShowMemory(cl, obj, (APTR)msg));
  480.         case MUIM_MainWin_ShowMounts:        return (mShowMounts(cl, obj, (APTR)msg));
  481.         case MUIM_MainWin_ShowPorts:         return (mShowPorts(cl, obj, (APTR)msg));
  482.         case MUIM_MainWin_ShowResidents:     return (mShowResidents(cl, obj, (APTR)msg));
  483.         case MUIM_MainWin_ShowCommands:      return (mShowCommands(cl, obj, (APTR)msg));
  484.         case MUIM_MainWin_ShowResources:     return (mShowResources(cl, obj, (APTR)msg));
  485.         case MUIM_MainWin_ShowScreenModes:   return (mShowScreenModes(cl, obj, (APTR)msg));
  486.         case MUIM_MainWin_ShowSemaphores:    return (mShowSemaphores(cl, obj, (APTR)msg));
  487.         case MUIM_MainWin_ShowSystem:        return (mShowSystem(cl, obj, (APTR)msg));
  488.         case MUIM_MainWin_ShowTasks:         return (mShowTasks(cl, obj, (APTR)msg));
  489.         case MUIM_MainWin_ShowTimers:        return (mShowTimers(cl, obj, (APTR)msg));
  490.         case MUIM_MainWin_ShowVectors:       return (mShowVectors(cl, obj, (APTR)msg));
  491.         case MUIM_MainWin_ShowWindows:       return (mShowWindows(cl, obj, (APTR)msg));
  492.         case MUIM_MainWin_ShowPatches:       return (mShowPatches(cl, obj, (APTR)msg));
  493.         case MUIM_MainWin_ShowCatalogs:      return (mShowCatalogs(cl, obj, (APTR)msg));
  494.         case MUIM_MainWin_ShowAudioModes:    return (mShowAudioModes(cl, obj, (APTR)msg));
  495.         case MUIM_MainWin_ShowResetHandlers: return (mShowResetHandlers(cl, obj, (APTR)msg));
  496.         case MUIM_MainWin_FlushDevices:      return (mFlushDevices(cl, obj, (APTR)msg));
  497.         case MUIM_MainWin_FlushFonts:        return (mFlushFonts(cl, obj, (APTR)msg));
  498.         case MUIM_MainWin_FlushLibraries:    return (mFlushLibraries(cl, obj, (APTR)msg));
  499.         case MUIM_MainWin_FlushAll:          return (mFlushAll(cl, obj, (APTR)msg));
  500.     }
  501.  
  502.     return (DoSuperMethodA(cl, obj, msg));
  503. }
  504.  
  505.